'Weak Dependency Graph [60.0]'
------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
Details:
We have computed the following set of weak (innermost) dependency pairs:
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(s(x1)) -> c_5()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, 0^#(x1) -> c_7()}
The usable rules are:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
The estimated dependency graph contains the following edges:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
==> {p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
==> {p^#(p(s(x1))) -> c_4(p^#(x1))}
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
==> {p^#(s(x1)) -> c_5()}
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
==> {p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
==> {p^#(p(s(x1))) -> c_4(p^#(x1))}
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
==> {p^#(s(x1)) -> c_5()}
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
==> {p^#(s(x1)) -> c_5()}
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
==> {p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
==> {p^#(p(s(x1))) -> c_4(p^#(x1))}
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
==> {p^#(s(x1)) -> c_5()}
{p^#(p(s(x1))) -> c_4(p^#(x1))}
==> {p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
{p^#(p(s(x1))) -> c_4(p^#(x1))}
==> {p^#(s(x1)) -> c_5()}
{p^#(p(s(x1))) -> c_4(p^#(x1))}
==> {p^#(p(s(x1))) -> c_4(p^#(x1))}
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
==> {0^#(x1) -> c_7()}
We consider the following path(s):
1) { twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, 0^#(x1) -> c_7()}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, 0^#(x1) -> c_7()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0^#(x1) -> c_7()}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0^#(x1) -> c_7()}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [8]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{ 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [8]
twoto^#(x1) = [1] x1 + [13]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [2]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(39) -> 28
, twoto_1(39) -> 32
, twoto_1(39) -> 38
, p_1(18) -> 28
, p_1(18) -> 32
, p_1(18) -> 38
, p_1(19) -> 18
, p_1(22) -> 21
, p_1(22) -> 28
, p_1(22) -> 32
, p_1(22) -> 38
, p_1(23) -> 22
, p_1(24) -> 23
, p_1(29) -> 28
, p_1(30) -> 29
, p_1(33) -> 28
, p_1(33) -> 32
, p_1(34) -> 33
, p_1(35) -> 34
, p_1(40) -> 39
, p_1(42) -> 39
, p_1(42) -> 41
, p_2(20) -> 28
, p_2(20) -> 32
, p_2(20) -> 38
, p_2(25) -> 22
, p_2(26) -> 21
, p_2(26) -> 28
, p_2(26) -> 32
, p_2(26) -> 38
, p_2(31) -> 28
, p_2(36) -> 33
, p_2(37) -> 28
, p_2(37) -> 32
, s_0(4) -> 4
, s_0(4) -> 39
, s_0(4) -> 41
, s_1(4) -> 42
, s_1(20) -> 19
, s_1(21) -> 18
, s_1(21) -> 20
, s_1(25) -> 24
, s_1(26) -> 23
, s_1(26) -> 25
, s_1(27) -> 22
, s_1(27) -> 26
, s_1(31) -> 30
, s_1(32) -> 29
, s_1(32) -> 31
, s_1(36) -> 35
, s_1(37) -> 34
, s_1(37) -> 36
, s_1(38) -> 33
, s_1(38) -> 37
, s_1(41) -> 40
, twice_1(28) -> 21
, twice_1(28) -> 27
, twice_1(28) -> 28
, twice_1(28) -> 32
, twice_1(28) -> 38
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(18) -> 17
, p^#_2(20) -> 43
, c_1_1(17) -> 6
, c_4_2(43) -> 17
, 0^#_0(4) -> 16
, c_7_0() -> 16}
2) { twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [15]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [8]
c_1(x1) = [1] x1 + [9]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [10]
twoto^#(x1) = [1] x1 + [13]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [2]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(39) -> 28
, twoto_1(39) -> 32
, twoto_1(39) -> 38
, p_1(18) -> 28
, p_1(18) -> 32
, p_1(18) -> 38
, p_1(19) -> 18
, p_1(22) -> 21
, p_1(22) -> 28
, p_1(22) -> 32
, p_1(22) -> 38
, p_1(23) -> 22
, p_1(24) -> 23
, p_1(29) -> 28
, p_1(30) -> 29
, p_1(33) -> 28
, p_1(33) -> 32
, p_1(34) -> 33
, p_1(35) -> 34
, p_1(40) -> 39
, p_1(42) -> 39
, p_1(42) -> 41
, p_2(20) -> 28
, p_2(20) -> 32
, p_2(20) -> 38
, p_2(25) -> 22
, p_2(26) -> 21
, p_2(26) -> 28
, p_2(26) -> 32
, p_2(26) -> 38
, p_2(31) -> 28
, p_2(36) -> 33
, p_2(37) -> 28
, p_2(37) -> 32
, s_0(4) -> 4
, s_0(4) -> 39
, s_0(4) -> 41
, s_1(4) -> 42
, s_1(20) -> 19
, s_1(21) -> 18
, s_1(21) -> 20
, s_1(25) -> 24
, s_1(26) -> 23
, s_1(26) -> 25
, s_1(27) -> 22
, s_1(27) -> 26
, s_1(31) -> 30
, s_1(32) -> 29
, s_1(32) -> 31
, s_1(36) -> 35
, s_1(37) -> 34
, s_1(37) -> 36
, s_1(38) -> 33
, s_1(38) -> 37
, s_1(41) -> 40
, twice_1(28) -> 21
, twice_1(28) -> 27
, twice_1(28) -> 28
, twice_1(28) -> 32
, twice_1(28) -> 38
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(18) -> 17
, c_1_1(17) -> 6
, 0^#_0(4) -> 16}
3) { twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, 0^#(x1) -> c_7()}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, 0^#(x1) -> c_7()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [4]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0^#(x1) -> c_7()}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0^#(x1) -> c_7()}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [15]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [8]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ 0^#(x1) -> c_7()
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ 0^#(x1) -> c_7()
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(39) -> 28
, twoto_1(39) -> 32
, twoto_1(39) -> 38
, p_1(18) -> 28
, p_1(18) -> 32
, p_1(18) -> 38
, p_1(19) -> 18
, p_1(22) -> 21
, p_1(22) -> 28
, p_1(22) -> 32
, p_1(22) -> 38
, p_1(23) -> 22
, p_1(24) -> 23
, p_1(29) -> 28
, p_1(30) -> 29
, p_1(33) -> 28
, p_1(33) -> 32
, p_1(34) -> 33
, p_1(35) -> 34
, p_1(40) -> 39
, p_1(42) -> 39
, p_1(42) -> 41
, p_2(20) -> 28
, p_2(20) -> 32
, p_2(20) -> 38
, p_2(25) -> 22
, p_2(26) -> 21
, p_2(26) -> 28
, p_2(26) -> 32
, p_2(26) -> 38
, p_2(31) -> 28
, p_2(36) -> 33
, p_2(37) -> 28
, p_2(37) -> 32
, s_0(4) -> 4
, s_0(4) -> 39
, s_0(4) -> 41
, s_1(4) -> 42
, s_1(20) -> 19
, s_1(21) -> 18
, s_1(21) -> 20
, s_1(25) -> 24
, s_1(26) -> 23
, s_1(26) -> 25
, s_1(27) -> 22
, s_1(27) -> 26
, s_1(31) -> 30
, s_1(32) -> 29
, s_1(32) -> 31
, s_1(36) -> 35
, s_1(37) -> 34
, s_1(37) -> 36
, s_1(38) -> 33
, s_1(38) -> 37
, s_1(41) -> 40
, twice_1(28) -> 21
, twice_1(28) -> 27
, twice_1(28) -> 28
, twice_1(28) -> 32
, twice_1(28) -> 38
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(18) -> 17
, c_1_1(17) -> 6
, 0^#_0(4) -> 16
, c_7_0() -> 16}
4) { twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(s(x1)) -> c_5()}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(s(x1)) -> c_5()}
and weakly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(s(x1)) -> c_5()}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [8]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ p^#(s(x1)) -> c_5()
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [1] x1 + [13]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [8]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(31) -> 20
, twoto_1(31) -> 24
, twoto_1(31) -> 30
, p_1(10) -> 20
, p_1(10) -> 24
, p_1(10) -> 30
, p_1(11) -> 10
, p_1(14) -> 13
, p_1(14) -> 20
, p_1(14) -> 24
, p_1(14) -> 30
, p_1(15) -> 14
, p_1(16) -> 15
, p_1(21) -> 20
, p_1(22) -> 21
, p_1(25) -> 20
, p_1(25) -> 24
, p_1(26) -> 25
, p_1(27) -> 26
, p_1(32) -> 31
, p_1(34) -> 31
, p_1(34) -> 33
, p_2(12) -> 20
, p_2(12) -> 24
, p_2(12) -> 30
, p_2(17) -> 14
, p_2(18) -> 13
, p_2(18) -> 20
, p_2(18) -> 24
, p_2(18) -> 30
, p_2(23) -> 20
, p_2(28) -> 25
, p_2(29) -> 20
, p_2(29) -> 24
, s_0(4) -> 4
, s_0(4) -> 31
, s_0(4) -> 33
, s_1(4) -> 34
, s_1(12) -> 11
, s_1(13) -> 10
, s_1(13) -> 12
, s_1(17) -> 16
, s_1(18) -> 15
, s_1(18) -> 17
, s_1(19) -> 14
, s_1(19) -> 18
, s_1(23) -> 22
, s_1(24) -> 21
, s_1(24) -> 23
, s_1(28) -> 27
, s_1(29) -> 26
, s_1(29) -> 28
, s_1(30) -> 25
, s_1(30) -> 29
, s_1(33) -> 32
, twice_1(20) -> 13
, twice_1(20) -> 19
, twice_1(20) -> 20
, twice_1(20) -> 24
, twice_1(20) -> 30
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(10) -> 9
, c_1_1(9) -> 6
, c_5_0() -> 8
, c_5_1() -> 9}
5) { twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [8]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [15]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [8]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [2]
twoto^#(x1) = [1] x1 + [13]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [4]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(39) -> 28
, twoto_1(39) -> 32
, twoto_1(39) -> 38
, p_1(18) -> 28
, p_1(18) -> 32
, p_1(18) -> 38
, p_1(19) -> 18
, p_1(22) -> 21
, p_1(22) -> 28
, p_1(22) -> 32
, p_1(22) -> 38
, p_1(23) -> 22
, p_1(24) -> 23
, p_1(29) -> 28
, p_1(30) -> 29
, p_1(33) -> 28
, p_1(33) -> 32
, p_1(34) -> 33
, p_1(35) -> 34
, p_1(40) -> 39
, p_1(42) -> 39
, p_1(42) -> 41
, p_2(20) -> 28
, p_2(20) -> 32
, p_2(20) -> 38
, p_2(25) -> 22
, p_2(26) -> 21
, p_2(26) -> 28
, p_2(26) -> 32
, p_2(26) -> 38
, p_2(31) -> 28
, p_2(36) -> 33
, p_2(37) -> 28
, p_2(37) -> 32
, s_0(4) -> 4
, s_0(4) -> 39
, s_0(4) -> 41
, s_1(4) -> 42
, s_1(20) -> 19
, s_1(21) -> 18
, s_1(21) -> 20
, s_1(25) -> 24
, s_1(26) -> 23
, s_1(26) -> 25
, s_1(27) -> 22
, s_1(27) -> 26
, s_1(31) -> 30
, s_1(32) -> 29
, s_1(32) -> 31
, s_1(36) -> 35
, s_1(37) -> 34
, s_1(37) -> 36
, s_1(38) -> 33
, s_1(38) -> 37
, s_1(41) -> 40
, twice_1(28) -> 21
, twice_1(28) -> 27
, twice_1(28) -> 28
, twice_1(28) -> 32
, twice_1(28) -> 38
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(18) -> 17
, p^#_2(20) -> 43
, c_1_1(17) -> 6
, c_4_2(43) -> 17
, 0^#_0(4) -> 16}
6) { twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(s(x1)) -> c_5()}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, p^#(s(x1)) -> c_5()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [3]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [5]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{ 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [8]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(31) -> 20
, twoto_1(31) -> 24
, twoto_1(31) -> 30
, p_1(10) -> 20
, p_1(10) -> 24
, p_1(10) -> 30
, p_1(11) -> 10
, p_1(14) -> 13
, p_1(14) -> 20
, p_1(14) -> 24
, p_1(14) -> 30
, p_1(15) -> 14
, p_1(16) -> 15
, p_1(21) -> 20
, p_1(22) -> 21
, p_1(25) -> 20
, p_1(25) -> 24
, p_1(26) -> 25
, p_1(27) -> 26
, p_1(32) -> 31
, p_1(34) -> 31
, p_1(34) -> 33
, p_2(12) -> 20
, p_2(12) -> 24
, p_2(12) -> 30
, p_2(17) -> 14
, p_2(18) -> 13
, p_2(18) -> 20
, p_2(18) -> 24
, p_2(18) -> 30
, p_2(23) -> 20
, p_2(28) -> 25
, p_2(29) -> 20
, p_2(29) -> 24
, s_0(4) -> 4
, s_0(4) -> 31
, s_0(4) -> 33
, s_1(4) -> 34
, s_1(12) -> 11
, s_1(13) -> 10
, s_1(13) -> 12
, s_1(17) -> 16
, s_1(18) -> 15
, s_1(18) -> 17
, s_1(19) -> 14
, s_1(19) -> 18
, s_1(23) -> 22
, s_1(24) -> 21
, s_1(24) -> 23
, s_1(28) -> 27
, s_1(29) -> 26
, s_1(29) -> 28
, s_1(30) -> 25
, s_1(30) -> 29
, s_1(33) -> 32
, twice_1(20) -> 13
, twice_1(20) -> 19
, twice_1(20) -> 20
, twice_1(20) -> 24
, twice_1(20) -> 30
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(10) -> 9
, p^#_2(12) -> 35
, c_1_1(9) -> 6
, c_4_2(35) -> 9
, c_5_0() -> 8
, c_5_1() -> 9
, c_5_2() -> 35}
7) { twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [1]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [9]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{ 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [10]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [6]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [2]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Weak Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(31) -> 20
, twoto_1(31) -> 24
, twoto_1(31) -> 30
, p_1(10) -> 20
, p_1(10) -> 24
, p_1(10) -> 30
, p_1(11) -> 10
, p_1(14) -> 13
, p_1(14) -> 20
, p_1(14) -> 24
, p_1(14) -> 30
, p_1(15) -> 14
, p_1(16) -> 15
, p_1(21) -> 20
, p_1(22) -> 21
, p_1(25) -> 20
, p_1(25) -> 24
, p_1(26) -> 25
, p_1(27) -> 26
, p_1(32) -> 31
, p_1(34) -> 31
, p_1(34) -> 33
, p_2(12) -> 20
, p_2(12) -> 24
, p_2(12) -> 30
, p_2(17) -> 14
, p_2(18) -> 13
, p_2(18) -> 20
, p_2(18) -> 24
, p_2(18) -> 30
, p_2(23) -> 20
, p_2(28) -> 25
, p_2(29) -> 20
, p_2(29) -> 24
, s_0(4) -> 4
, s_0(4) -> 31
, s_0(4) -> 33
, s_1(4) -> 34
, s_1(12) -> 11
, s_1(13) -> 10
, s_1(13) -> 12
, s_1(17) -> 16
, s_1(18) -> 15
, s_1(18) -> 17
, s_1(19) -> 14
, s_1(19) -> 18
, s_1(23) -> 22
, s_1(24) -> 21
, s_1(24) -> 23
, s_1(28) -> 27
, s_1(29) -> 26
, s_1(29) -> 28
, s_1(30) -> 25
, s_1(30) -> 29
, s_1(33) -> 32
, twice_1(20) -> 13
, twice_1(20) -> 19
, twice_1(20) -> 20
, twice_1(20) -> 24
, twice_1(20) -> 30
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(10) -> 9
, p^#_2(12) -> 35
, c_1_1(9) -> 6
, c_4_2(35) -> 9}
8) {twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
The usable rules for this path are the following:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [8]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
and weakly orienting the rules
{ twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [1]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [1] x1 + [1]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [1] x1 + [2]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twoto(s(x1)) ->
p(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1))))))))))))))))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ 0(x1) -> x1
, twoto^#(s(x1)) ->
c_1(p^#(p(s(s(p(p(p(s(s(s(twice(p(p(s(s(p(p(p(s(s(s(twoto(p(s(p(s(x1)))))))))))))))))))))))))))
, twoto(0(x1)) ->
p(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ twoto_1(31) -> 20
, twoto_1(31) -> 24
, twoto_1(31) -> 30
, p_1(10) -> 20
, p_1(10) -> 24
, p_1(10) -> 30
, p_1(11) -> 10
, p_1(14) -> 13
, p_1(14) -> 20
, p_1(14) -> 24
, p_1(14) -> 30
, p_1(15) -> 14
, p_1(16) -> 15
, p_1(21) -> 20
, p_1(22) -> 21
, p_1(25) -> 20
, p_1(25) -> 24
, p_1(26) -> 25
, p_1(27) -> 26
, p_1(32) -> 31
, p_1(34) -> 31
, p_1(34) -> 33
, p_2(12) -> 20
, p_2(12) -> 24
, p_2(12) -> 30
, p_2(17) -> 14
, p_2(18) -> 13
, p_2(18) -> 20
, p_2(18) -> 24
, p_2(18) -> 30
, p_2(23) -> 20
, p_2(28) -> 25
, p_2(29) -> 20
, p_2(29) -> 24
, s_0(4) -> 4
, s_0(4) -> 31
, s_0(4) -> 33
, s_1(4) -> 34
, s_1(12) -> 11
, s_1(13) -> 10
, s_1(13) -> 12
, s_1(17) -> 16
, s_1(18) -> 15
, s_1(18) -> 17
, s_1(19) -> 14
, s_1(19) -> 18
, s_1(23) -> 22
, s_1(24) -> 21
, s_1(24) -> 23
, s_1(28) -> 27
, s_1(29) -> 26
, s_1(29) -> 28
, s_1(30) -> 25
, s_1(30) -> 29
, s_1(33) -> 32
, twice_1(20) -> 13
, twice_1(20) -> 19
, twice_1(20) -> 20
, twice_1(20) -> 24
, twice_1(20) -> 30
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, p^#_1(10) -> 9
, c_1_1(9) -> 6}
9) { twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, 0^#(x1) -> c_7()}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, 0^#(x1) -> c_7()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [6]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [7]
c_4(x1) = [1] x1 + [7]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0^#(x1) -> c_7()}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0^#(x1) -> c_7()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [6]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [15]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 27
, p_0(4) -> 29
, p_0(4) -> 31
, p_0(4) -> 33
, p_0(19) -> 18
, p_0(20) -> 19
, p_0(21) -> 20
, p_0(22) -> 19
, p_0(23) -> 18
, p_0(28) -> 27
, p_0(30) -> 27
, p_0(30) -> 29
, p_0(32) -> 27
, p_0(32) -> 29
, p_0(32) -> 31
, p_1(36) -> 35
, p_1(37) -> 36
, p_1(38) -> 37
, p_1(39) -> 38
, p_1(40) -> 37
, p_1(41) -> 36
, p_1(42) -> 35
, p_1(46) -> 45
, p_1(48) -> 45
, p_1(48) -> 47
, p_1(50) -> 45
, p_1(50) -> 47
, p_1(50) -> 49
, p_1(52) -> 45
, p_1(52) -> 47
, p_1(52) -> 49
, p_1(52) -> 51
, s_0(4) -> 4
, s_0(4) -> 27
, s_0(4) -> 29
, s_0(4) -> 31
, s_0(4) -> 33
, s_0(4) -> 45
, s_0(4) -> 47
, s_0(4) -> 49
, s_0(4) -> 51
, s_0(22) -> 21
, s_0(23) -> 20
, s_0(23) -> 22
, s_0(24) -> 19
, s_0(24) -> 23
, s_0(25) -> 18
, s_0(25) -> 24
, s_0(26) -> 25
, s_0(29) -> 28
, s_0(31) -> 30
, s_0(33) -> 32
, s_1(4) -> 52
, s_1(35) -> 26
, s_1(35) -> 44
, s_1(40) -> 39
, s_1(41) -> 38
, s_1(41) -> 40
, s_1(42) -> 37
, s_1(42) -> 41
, s_1(43) -> 36
, s_1(43) -> 42
, s_1(44) -> 35
, s_1(44) -> 43
, s_1(47) -> 46
, s_1(49) -> 48
, s_1(51) -> 50
, twice_0(27) -> 26
, twice_1(45) -> 44
, p^#_0(4) -> 8
, p^#_0(18) -> 17
, p^#_0(24) -> 34
, p^#_1(36) -> 53
, p^#_1(42) -> 54
, twice^#_0(4) -> 10
, c_3_0(17) -> 10
, c_3_1(53) -> 10
, c_4_0(34) -> 17
, c_4_1(54) -> 53
, 0^#_0(4) -> 16
, c_7_0() -> 16}
10)
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, 0^#(x1) -> c_7()}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, 0^#(x1) -> c_7()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [6]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [5]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0^#(x1) -> c_7()}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0^#(x1) -> c_7()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [15]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [5]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [8]
0^#(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [7]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [5]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [8]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [15]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 27
, p_0(4) -> 29
, p_0(4) -> 31
, p_0(4) -> 33
, p_0(19) -> 18
, p_0(20) -> 19
, p_0(21) -> 20
, p_0(22) -> 19
, p_0(23) -> 18
, p_0(28) -> 27
, p_0(30) -> 27
, p_0(30) -> 29
, p_0(32) -> 27
, p_0(32) -> 29
, p_0(32) -> 31
, p_1(35) -> 34
, p_1(36) -> 35
, p_1(37) -> 36
, p_1(38) -> 37
, p_1(39) -> 36
, p_1(40) -> 35
, p_1(41) -> 34
, p_1(45) -> 44
, p_1(47) -> 44
, p_1(47) -> 46
, p_1(49) -> 44
, p_1(49) -> 46
, p_1(49) -> 48
, p_1(51) -> 44
, p_1(51) -> 46
, p_1(51) -> 48
, p_1(51) -> 50
, s_0(4) -> 4
, s_0(4) -> 27
, s_0(4) -> 29
, s_0(4) -> 31
, s_0(4) -> 33
, s_0(4) -> 44
, s_0(4) -> 46
, s_0(4) -> 48
, s_0(4) -> 50
, s_0(22) -> 21
, s_0(23) -> 20
, s_0(23) -> 22
, s_0(24) -> 19
, s_0(24) -> 23
, s_0(25) -> 18
, s_0(25) -> 24
, s_0(26) -> 25
, s_0(29) -> 28
, s_0(31) -> 30
, s_0(33) -> 32
, s_1(4) -> 51
, s_1(34) -> 26
, s_1(34) -> 43
, s_1(39) -> 38
, s_1(40) -> 37
, s_1(40) -> 39
, s_1(41) -> 36
, s_1(41) -> 40
, s_1(42) -> 35
, s_1(42) -> 41
, s_1(43) -> 34
, s_1(43) -> 42
, s_1(46) -> 45
, s_1(48) -> 47
, s_1(50) -> 49
, twice_0(27) -> 26
, twice_1(44) -> 43
, p^#_0(4) -> 8
, p^#_0(18) -> 17
, p^#_1(35) -> 52
, twice^#_0(4) -> 10
, c_3_0(17) -> 10
, c_3_1(52) -> 10
, 0^#_0(4) -> 16
, c_7_0() -> 16}
11)
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [8]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [2]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [3]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [8]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [8]
0^#(x1) = [1] x1 + [8]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [8]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [15]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 27
, p_0(4) -> 29
, p_0(4) -> 31
, p_0(4) -> 33
, p_0(19) -> 18
, p_0(20) -> 19
, p_0(21) -> 20
, p_0(22) -> 19
, p_0(23) -> 18
, p_0(28) -> 27
, p_0(30) -> 27
, p_0(30) -> 29
, p_0(32) -> 27
, p_0(32) -> 29
, p_0(32) -> 31
, p_1(35) -> 34
, p_1(36) -> 35
, p_1(37) -> 36
, p_1(38) -> 37
, p_1(39) -> 36
, p_1(40) -> 35
, p_1(41) -> 34
, p_1(45) -> 44
, p_1(47) -> 44
, p_1(47) -> 46
, p_1(49) -> 44
, p_1(49) -> 46
, p_1(49) -> 48
, p_1(51) -> 44
, p_1(51) -> 46
, p_1(51) -> 48
, p_1(51) -> 50
, s_0(4) -> 4
, s_0(4) -> 27
, s_0(4) -> 29
, s_0(4) -> 31
, s_0(4) -> 33
, s_0(4) -> 44
, s_0(4) -> 46
, s_0(4) -> 48
, s_0(4) -> 50
, s_0(22) -> 21
, s_0(23) -> 20
, s_0(23) -> 22
, s_0(24) -> 19
, s_0(24) -> 23
, s_0(25) -> 18
, s_0(25) -> 24
, s_0(26) -> 25
, s_0(29) -> 28
, s_0(31) -> 30
, s_0(33) -> 32
, s_1(4) -> 51
, s_1(34) -> 26
, s_1(34) -> 43
, s_1(39) -> 38
, s_1(40) -> 37
, s_1(40) -> 39
, s_1(41) -> 36
, s_1(41) -> 40
, s_1(42) -> 35
, s_1(42) -> 41
, s_1(43) -> 34
, s_1(43) -> 42
, s_1(46) -> 45
, s_1(48) -> 47
, s_1(50) -> 49
, twice_0(27) -> 26
, twice_1(44) -> 43
, p^#_0(4) -> 8
, p^#_0(18) -> 17
, p^#_1(35) -> 52
, twice^#_0(4) -> 10
, c_3_0(17) -> 10
, c_3_1(52) -> 10
, 0^#_0(4) -> 16}
12)
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(s(x1)) -> c_5()}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(s(x1)) -> c_5()}
and weakly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(s(x1)) -> c_5()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{ p^#(s(x1)) -> c_5()
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(s(x1)) -> c_5()
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [3]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(s(x1)) -> c_5()
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [14]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [13]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(s(x1)) -> c_5()
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(s(x1)) -> c_5()
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 21
, p_0(4) -> 23
, p_0(4) -> 25
, p_0(4) -> 27
, p_0(13) -> 12
, p_0(14) -> 13
, p_0(15) -> 14
, p_0(16) -> 13
, p_0(17) -> 12
, p_0(22) -> 21
, p_0(24) -> 21
, p_0(24) -> 23
, p_0(26) -> 21
, p_0(26) -> 23
, p_0(26) -> 25
, p_1(29) -> 28
, p_1(30) -> 29
, p_1(31) -> 30
, p_1(32) -> 31
, p_1(33) -> 30
, p_1(34) -> 29
, p_1(35) -> 28
, p_1(39) -> 38
, p_1(41) -> 38
, p_1(41) -> 40
, p_1(43) -> 38
, p_1(43) -> 40
, p_1(43) -> 42
, p_1(45) -> 38
, p_1(45) -> 40
, p_1(45) -> 42
, p_1(45) -> 44
, s_0(4) -> 4
, s_0(4) -> 21
, s_0(4) -> 23
, s_0(4) -> 25
, s_0(4) -> 27
, s_0(4) -> 38
, s_0(4) -> 40
, s_0(4) -> 42
, s_0(4) -> 44
, s_0(16) -> 15
, s_0(17) -> 14
, s_0(17) -> 16
, s_0(18) -> 13
, s_0(18) -> 17
, s_0(19) -> 12
, s_0(19) -> 18
, s_0(20) -> 19
, s_0(23) -> 22
, s_0(25) -> 24
, s_0(27) -> 26
, s_1(4) -> 45
, s_1(28) -> 20
, s_1(28) -> 37
, s_1(33) -> 32
, s_1(34) -> 31
, s_1(34) -> 33
, s_1(35) -> 30
, s_1(35) -> 34
, s_1(36) -> 29
, s_1(36) -> 35
, s_1(37) -> 28
, s_1(37) -> 36
, s_1(40) -> 39
, s_1(42) -> 41
, s_1(44) -> 43
, twice_0(21) -> 20
, twice_1(38) -> 37
, p^#_0(4) -> 8
, p^#_0(12) -> 11
, p^#_1(29) -> 46
, twice^#_0(4) -> 10
, c_3_0(11) -> 10
, c_3_1(46) -> 10
, c_5_0() -> 8
, c_5_0() -> 11
, c_5_1() -> 46}
13)
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [1]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [8]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [15]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 27
, p_0(4) -> 29
, p_0(4) -> 31
, p_0(4) -> 33
, p_0(19) -> 18
, p_0(20) -> 19
, p_0(21) -> 20
, p_0(22) -> 19
, p_0(23) -> 18
, p_0(28) -> 27
, p_0(30) -> 27
, p_0(30) -> 29
, p_0(32) -> 27
, p_0(32) -> 29
, p_0(32) -> 31
, p_1(36) -> 35
, p_1(37) -> 36
, p_1(38) -> 37
, p_1(39) -> 38
, p_1(40) -> 37
, p_1(41) -> 36
, p_1(42) -> 35
, p_1(46) -> 45
, p_1(48) -> 45
, p_1(48) -> 47
, p_1(50) -> 45
, p_1(50) -> 47
, p_1(50) -> 49
, p_1(52) -> 45
, p_1(52) -> 47
, p_1(52) -> 49
, p_1(52) -> 51
, s_0(4) -> 4
, s_0(4) -> 27
, s_0(4) -> 29
, s_0(4) -> 31
, s_0(4) -> 33
, s_0(4) -> 45
, s_0(4) -> 47
, s_0(4) -> 49
, s_0(4) -> 51
, s_0(22) -> 21
, s_0(23) -> 20
, s_0(23) -> 22
, s_0(24) -> 19
, s_0(24) -> 23
, s_0(25) -> 18
, s_0(25) -> 24
, s_0(26) -> 25
, s_0(29) -> 28
, s_0(31) -> 30
, s_0(33) -> 32
, s_1(4) -> 52
, s_1(35) -> 26
, s_1(35) -> 44
, s_1(40) -> 39
, s_1(41) -> 38
, s_1(41) -> 40
, s_1(42) -> 37
, s_1(42) -> 41
, s_1(43) -> 36
, s_1(43) -> 42
, s_1(44) -> 35
, s_1(44) -> 43
, s_1(47) -> 46
, s_1(49) -> 48
, s_1(51) -> 50
, twice_0(27) -> 26
, twice_1(45) -> 44
, p^#_0(4) -> 8
, p^#_0(18) -> 17
, p^#_0(24) -> 34
, p^#_1(36) -> 53
, p^#_1(42) -> 54
, twice^#_0(4) -> 10
, c_3_0(17) -> 10
, c_3_1(53) -> 10
, c_4_0(34) -> 17
, c_4_1(54) -> 53
, 0^#_0(4) -> 16}
14)
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [4]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [2]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [11]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [13]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [8]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [12]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p^#(p(s(x1))) -> c_4(p^#(x1))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p^#(p(s(x1))) -> c_4(p^#(x1))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 21
, p_0(4) -> 23
, p_0(4) -> 25
, p_0(4) -> 27
, p_0(13) -> 12
, p_0(14) -> 13
, p_0(15) -> 14
, p_0(16) -> 13
, p_0(17) -> 12
, p_0(22) -> 21
, p_0(24) -> 21
, p_0(24) -> 23
, p_0(26) -> 21
, p_0(26) -> 23
, p_0(26) -> 25
, p_1(30) -> 29
, p_1(31) -> 30
, p_1(32) -> 31
, p_1(33) -> 32
, p_1(34) -> 31
, p_1(35) -> 30
, p_1(36) -> 29
, p_1(40) -> 39
, p_1(42) -> 39
, p_1(42) -> 41
, p_1(44) -> 39
, p_1(44) -> 41
, p_1(44) -> 43
, p_1(46) -> 39
, p_1(46) -> 41
, p_1(46) -> 43
, p_1(46) -> 45
, s_0(4) -> 4
, s_0(4) -> 21
, s_0(4) -> 23
, s_0(4) -> 25
, s_0(4) -> 27
, s_0(4) -> 39
, s_0(4) -> 41
, s_0(4) -> 43
, s_0(4) -> 45
, s_0(16) -> 15
, s_0(17) -> 14
, s_0(17) -> 16
, s_0(18) -> 13
, s_0(18) -> 17
, s_0(19) -> 12
, s_0(19) -> 18
, s_0(20) -> 19
, s_0(23) -> 22
, s_0(25) -> 24
, s_0(27) -> 26
, s_1(4) -> 46
, s_1(29) -> 20
, s_1(29) -> 38
, s_1(34) -> 33
, s_1(35) -> 32
, s_1(35) -> 34
, s_1(36) -> 31
, s_1(36) -> 35
, s_1(37) -> 30
, s_1(37) -> 36
, s_1(38) -> 29
, s_1(38) -> 37
, s_1(41) -> 40
, s_1(43) -> 42
, s_1(45) -> 44
, twice_0(21) -> 20
, twice_1(39) -> 38
, p^#_0(4) -> 8
, p^#_0(12) -> 11
, p^#_0(18) -> 28
, p^#_1(30) -> 47
, p^#_1(36) -> 48
, twice^#_0(4) -> 10
, c_3_0(11) -> 10
, c_3_1(47) -> 10
, c_4_0(28) -> 11
, c_4_1(48) -> 47}
15)
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(s(x1)) -> c_5()}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, p^#(s(x1)) -> c_5()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [9]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [6]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [4]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [4]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [8]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [15]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 21
, p_0(4) -> 23
, p_0(4) -> 25
, p_0(4) -> 27
, p_0(13) -> 12
, p_0(14) -> 13
, p_0(15) -> 14
, p_0(16) -> 13
, p_0(17) -> 12
, p_0(22) -> 21
, p_0(24) -> 21
, p_0(24) -> 23
, p_0(26) -> 21
, p_0(26) -> 23
, p_0(26) -> 25
, p_1(30) -> 29
, p_1(31) -> 30
, p_1(32) -> 31
, p_1(33) -> 32
, p_1(34) -> 31
, p_1(35) -> 30
, p_1(36) -> 29
, p_1(40) -> 39
, p_1(42) -> 39
, p_1(42) -> 41
, p_1(44) -> 39
, p_1(44) -> 41
, p_1(44) -> 43
, p_1(46) -> 39
, p_1(46) -> 41
, p_1(46) -> 43
, p_1(46) -> 45
, s_0(4) -> 4
, s_0(4) -> 21
, s_0(4) -> 23
, s_0(4) -> 25
, s_0(4) -> 27
, s_0(4) -> 39
, s_0(4) -> 41
, s_0(4) -> 43
, s_0(4) -> 45
, s_0(16) -> 15
, s_0(17) -> 14
, s_0(17) -> 16
, s_0(18) -> 13
, s_0(18) -> 17
, s_0(19) -> 12
, s_0(19) -> 18
, s_0(20) -> 19
, s_0(23) -> 22
, s_0(25) -> 24
, s_0(27) -> 26
, s_1(4) -> 46
, s_1(29) -> 20
, s_1(29) -> 38
, s_1(34) -> 33
, s_1(35) -> 32
, s_1(35) -> 34
, s_1(36) -> 31
, s_1(36) -> 35
, s_1(37) -> 30
, s_1(37) -> 36
, s_1(38) -> 29
, s_1(38) -> 37
, s_1(41) -> 40
, s_1(43) -> 42
, s_1(45) -> 44
, twice_0(21) -> 20
, twice_1(39) -> 38
, p^#_0(4) -> 8
, p^#_0(12) -> 11
, p^#_0(18) -> 28
, p^#_1(30) -> 47
, p^#_1(36) -> 48
, twice^#_0(4) -> 10
, c_3_0(11) -> 10
, c_3_1(47) -> 10
, c_4_0(28) -> 11
, c_4_1(48) -> 47
, c_5_0() -> 8
, c_5_0() -> 11
, c_5_0() -> 28
, c_5_1() -> 47
, c_5_1() -> 48}
16)
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
The usable rules for this path are the following:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))
, twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
and weakly orienting the rules
{twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [1]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [1]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [1] x1 + [4]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [11]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ twice(s(x1)) ->
s(p(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(s(x1)) ->
c_3(p^#(p(p(p(s(s(s(s(s(twice(p(s(p(s(p(s(p(s(x1)))))))))))))))))))
, twice(0(x1)) -> p(s(p(s(0(s(p(s(s(s(s(p(s(x1)))))))))))))}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ p_0(4) -> 21
, p_0(4) -> 23
, p_0(4) -> 25
, p_0(4) -> 27
, p_0(13) -> 12
, p_0(14) -> 13
, p_0(15) -> 14
, p_0(16) -> 13
, p_0(17) -> 12
, p_0(22) -> 21
, p_0(24) -> 21
, p_0(24) -> 23
, p_0(26) -> 21
, p_0(26) -> 23
, p_0(26) -> 25
, p_1(29) -> 28
, p_1(30) -> 29
, p_1(31) -> 30
, p_1(32) -> 31
, p_1(33) -> 30
, p_1(34) -> 29
, p_1(35) -> 28
, p_1(39) -> 38
, p_1(41) -> 38
, p_1(41) -> 40
, p_1(43) -> 38
, p_1(43) -> 40
, p_1(43) -> 42
, p_1(45) -> 38
, p_1(45) -> 40
, p_1(45) -> 42
, p_1(45) -> 44
, s_0(4) -> 4
, s_0(4) -> 21
, s_0(4) -> 23
, s_0(4) -> 25
, s_0(4) -> 27
, s_0(4) -> 38
, s_0(4) -> 40
, s_0(4) -> 42
, s_0(4) -> 44
, s_0(16) -> 15
, s_0(17) -> 14
, s_0(17) -> 16
, s_0(18) -> 13
, s_0(18) -> 17
, s_0(19) -> 12
, s_0(19) -> 18
, s_0(20) -> 19
, s_0(23) -> 22
, s_0(25) -> 24
, s_0(27) -> 26
, s_1(4) -> 45
, s_1(28) -> 20
, s_1(28) -> 37
, s_1(33) -> 32
, s_1(34) -> 31
, s_1(34) -> 33
, s_1(35) -> 30
, s_1(35) -> 34
, s_1(36) -> 29
, s_1(36) -> 35
, s_1(37) -> 28
, s_1(37) -> 36
, s_1(40) -> 39
, s_1(42) -> 41
, s_1(44) -> 43
, twice_0(21) -> 20
, twice_1(38) -> 37
, p^#_0(4) -> 8
, p^#_0(12) -> 11
, p^#_1(29) -> 46
, twice^#_0(4) -> 10
, c_3_0(11) -> 10
, c_3_1(46) -> 10}
17)
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, 0^#(x1) -> c_7()}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, 0^#(x1) -> c_7()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [7]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [7]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0^#(x1) -> c_7()}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0^#(x1) -> c_7()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [1]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [13]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [3]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, 0^#_0(4) -> 16
, c_7_0() -> 16}
18)
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, 0^#(x1) -> c_7()}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, 0^#(x1) -> c_7()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [7]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0^#(x1) -> c_7()}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0^#(x1) -> c_7()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [1]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [12]
c_0(x1) = [1] x1 + [4]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, 0^#(x1) -> c_7()
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, 0^#_0(4) -> 16
, c_7_0() -> 16}
19)
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(s(x1)) -> c_5()}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
We apply the weight gap principle, strictly orienting the rules
{p^#(s(x1)) -> c_5()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(s(x1)) -> c_5()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [7]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [7]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [12]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [3]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p^#(p(s(x1))) -> c_4(p^#(x1))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p^#(p(s(x1))) -> c_4(p^#(x1))
, p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, c_5_0() -> 8}
20)
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, 0^#_0(4) -> 16}
21)
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [1]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [1]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [15]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [7]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
0^#(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, 0(x1) -> x1
, p^#(0(x1)) -> c_6(0^#(s(s(s(s(p(s(x1))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, 0^#_0(4) -> 16}
22)
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(s(x1)) -> c_5()}
and weakly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(s(x1)) -> c_5()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ p^#(s(x1)) -> c_5()
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [13]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8
, c_5_0() -> 8}
23)
{ twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))
, p^#(s(x1)) -> c_5()}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))
, p^#(s(x1)) -> c_5()}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{p^#(s(x1)) -> c_5()}
and weakly orienting the rules
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{p^#(s(x1)) -> c_5()}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [3]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{ p^#(s(x1)) -> c_5()
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [9]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [4]
p(x1) = [1] x1 + [4]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [1]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [13]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, p^#(s(x1)) -> c_5()
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, p^#_0(4) -> 8
, twice^#_0(4) -> 10
, c_5_0() -> 8}
24)
{ twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [1]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
and weakly orienting the rules
{ 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [12]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [1]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [15]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [7]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p^#(p(s(x1))) -> c_4(p^#(x1))
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8}
25)
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [2]
p(x1) = [1] x1 + [1]
s(x1) = [1] x1 + [1]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [1] x1 + [15]
c_0(x1) = [1] x1 + [1]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twoto^#(0(x1)) ->
c_0(p^#(p(s(s(s(p(p(p(s(s(s(0(p(p(s(s(x1)))))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, twoto^#_0(4) -> 6
, p^#_0(4) -> 8}
26)
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
The usable rules for this path are the following:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))
, 0(x1) -> x1
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [0]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{0(x1) -> x1}
and weakly orienting the rules
{twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{0(x1) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [8]
p(x1) = [1] x1 + [0]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [0]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [1]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
and weakly orienting the rules
{ 0(x1) -> x1
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1}
Details:
Interpretation Functions:
twoto(x1) = [0] x1 + [0]
0(x1) = [1] x1 + [12]
p(x1) = [1] x1 + [2]
s(x1) = [1] x1 + [0]
twice(x1) = [0] x1 + [0]
twoto^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
p^#(x1) = [1] x1 + [6]
c_1(x1) = [0] x1 + [0]
twice^#(x1) = [1] x1 + [13]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
0^#(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {p(0(x1)) -> 0(s(s(s(s(p(s(x1)))))))}
Weak Rules:
{ p(p(s(x1))) -> p(x1)
, p(s(x1)) -> x1
, 0(x1) -> x1
, twice^#(0(x1)) ->
c_2(p^#(s(p(s(0(s(p(s(s(s(s(p(s(x1))))))))))))))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ s_0(4) -> 4
, p^#_0(4) -> 8
, twice^#_0(4) -> 10}